In [0]:
# !pip install tensorflow-gpu=='2.1.0rc0'
In [0]:
from __future__ import absolute_import, division, print_function, unicode_literals
import tensorflow as tf
AUTOTUNE = tf.data.experimental.AUTOTUNE
import IPython.display as display
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
import os
In [3]:
tf.__version__
Out[3]:
In [4]:
claz = {0:'plane',1:'tesla',2:'shuttle'}
device_name = tf.test.gpu_device_name()
if device_name != '/device:GPU:0':
raise SystemError('GPU device not found')
print('Found GPU at: {}'.format(device_name))
In [5]:
from google.colab import drive
drive.mount('/content/dirve')
In [0]:
import pathlib
valid_data_dir = '/content/dirve/My Drive/Colab Notebooks/TransferLearningData/test'
train_data_dir = '/content/dirve/My Drive/Colab Notebooks/TransferLearningData/train'
valid_data_dir = pathlib.Path(valid_data_dir)
train_data_dir = pathlib.Path(train_data_dir)
In [7]:
valid_image_count = len(list(valid_data_dir.glob('*/*.jpg')))
train_image_count= len(list(train_data_dir.glob('*/*.jpg')))
print(f'VALID: {valid_image_count}, TRAIN: {train_image_count}')
In [8]:
CLASS_NAMES = np.array([item.name for item in train_data_dir.glob('*')])
CLASS_NAMES
Out[8]:
In [0]:
image_generator = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1./255)
In [0]:
BATCH_SIZE = 32
IMG_HEIGHT = 256
IMG_WIDTH = 256
STEPS_PER_EPOCH = np.ceil(train_image_count/BATCH_SIZE)
In [0]:
def draw_charts(history):
acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']
plt.figure(figsize=(8, 8))
plt.subplot(2, 1, 1)
plt.plot(acc, label='Training Accuracy')
plt.plot(val_acc, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.ylabel('Accuracy')
plt.ylim([min(plt.ylim()),1])
plt.title('Training and Validation Accuracy')
plt.subplot(2, 1, 2)
plt.plot(loss, label='Training Loss')
plt.plot(val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.ylabel('Cross Entropy')
plt.ylim([0,1.0])
plt.title('Training and Validation Loss')
plt.xlabel('epoch')
plt.show()
In [12]:
train_data_gen = image_generator.flow_from_directory(directory=str(train_data_dir),
batch_size=BATCH_SIZE,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
valid_data_gen = image_generator.flow_from_directory(directory=str(valid_data_dir),
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
In [0]:
def show_batch(image_batch, label_batch):
plt.figure(figsize=(10,10))
for n in range(25):
ax = plt.subplot(5,5,n+1)
plt.imshow(image_batch[n])
plt.title(CLASS_NAMES[label_batch[n]==1][0].title())
plt.axis('off')
In [0]:
image_batch, label_batch = next(train_data_gen)
In [15]:
show_batch(image_batch,label_batch)
In [16]:
show_batch(*next(valid_data_gen))
In [0]:
keras = tf.keras
In [18]:
IMG_SHAPE = (IMG_HEIGHT, IMG_WIDTH, 3)
base_model = tf.keras.applications.MobileNetV2(input_shape=IMG_SHAPE,
include_top=False,
weights='imagenet')
In [0]:
base_model.trainable = False
image_batch, label_batch = next(train_data_gen)
In [0]:
feature_batch = base_model(image_batch)
In [21]:
global_average_layer = tf.keras.layers.GlobalAveragePooling2D()
feature_batch_average = global_average_layer(feature_batch)
print(feature_batch_average.shape)
In [22]:
prediction_layer = keras.layers.Dense(3,activation="softmax")
prediction_batch = prediction_layer(feature_batch_average)
print(prediction_batch.shape)
10 trainings
In [0]:
model_1 = tf.keras.Sequential([
base_model,
global_average_layer,
prediction_layer
])
In [0]:
base_learning_rate = 0.0001
base_momentum=0.9
model_1.compile(optimizer=tf.keras.optimizers.SGD(lr=base_learning_rate, momentum=base_momentum),
loss='categorical_crossentropy',
metrics=['accuracy'])
In [25]:
history = model_1.fit(train_data_gen,
epochs=10,
validation_data=valid_data_gen)
In [26]:
draw_charts(history)
50 trainings
In [0]:
model_2 = tf.keras.Sequential([
base_model,
global_average_layer,
prediction_layer
])
In [0]:
base_learning_rate = 0.0001
base_momentum=0.9
model_2.compile(optimizer=tf.keras.optimizers.SGD(lr=base_learning_rate, momentum=base_momentum),
loss='categorical_crossentropy',
metrics=['accuracy'])
In [29]:
history = model_2.fit(train_data_gen,
epochs=50,
validation_data=valid_data_gen)
In [30]:
draw_charts(history)
In [0]:
Widzimy że wraz ze wzrostem ilości iteracji `accuracy` już nie rośnie i wacha się wokół maximum, sieć się nasyciła
Not mobile network
In [31]:
model = keras.applications.VGG19(weights = "imagenet", include_top=False, input_shape = (IMG_HEIGHT, IMG_WIDTH, 3))
for layer in model.layers[:5]:
layer.trainable = False
x = model.output
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(1024, activation="relu")(x)
x = keras.layers.Dropout(0.5)(x)
x = keras.layers.Dense(1024, activation="relu")(x)
predictions = keras.layers.Dense(3, activation="softmax")(x)
model_3 = keras.models.Model(inputs = model.input, outputs = predictions)
model_3.compile(loss = "categorical_crossentropy", optimizer = keras.optimizers.SGD(lr=0.0001, momentum=0.9), metrics=["accuracy"])
history = model_3.fit(train_data_gen,
epochs=10,
validation_data=valid_data_gen)
In [32]:
draw_charts(history)
Większa sieć z większym klasyfikatorem uczy się znacznie lepiej zwłaszcza odróżniać podobne klasy
In [33]:
wirdo_image_generator = tf.keras.preprocessing.image.ImageDataGenerator(
rescale=1./255,
horizontal_flip = True,
fill_mode = "nearest",
zoom_range = 0.3,
width_shift_range = 0.3,
height_shift_range=0.3,
rotation_range=30)
train_data_gen = wirdo_image_generator.flow_from_directory(directory=str(train_data_dir),
batch_size=BATCH_SIZE,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
valid_data_gen = image_generator.flow_from_directory(directory=str(valid_data_dir),
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
In [34]:
show_batch(*next(train_data_gen))
In [35]:
show_batch(*next(valid_data_gen))
In [36]:
model = keras.applications.VGG19(weights = "imagenet", include_top=False, input_shape = (IMG_HEIGHT, IMG_WIDTH, 3))
for layer in model.layers[:5]:
layer.trainable = False
x = model.output
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(1024, activation="relu")(x)
x = keras.layers.Dropout(0.5)(x)
x = keras.layers.Dense(1024, activation="relu")(x)
predictions = keras.layers.Dense(3, activation="softmax")(x)
model_4 = keras.models.Model(inputs = model.input, outputs = predictions)
model_4.compile(loss = "categorical_crossentropy", optimizer = keras.optimizers.SGD(lr=0.0001, momentum=0.9), metrics=["accuracy"])
history = model_4.fit(train_data_gen,
epochs=10,
validation_data=valid_data_gen)
model_4
Out[36]:
In [37]:
draw_charts(history)
Momo zniekształconego wejścia sieć ciągle dobrze się uczy, choć wolniej niż dla niezniekształconego wejścia
In [39]:
valid_data_gen = image_generator.flow_from_directory(directory=str(valid_data_dir),
batch_size=346,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
a,b= next(valid_data_gen)
n_preds = model_1.predict_classes(a)
preds = n_preds != np.argmax(b,axis=1)
claz = {0:'plane',1:'tesla',2:'shuttle'}
for img,nn_prediction,expected in zip(a[preds],n_preds[preds],np.argmax(b,axis=1)[preds]):
print(f'{claz[nn_prediction]} expected to be {claz[expected]}')
plt.imshow(img)
plt.show()
In [40]:
valid_data_gen = image_generator.flow_from_directory(directory=str(valid_data_dir),
batch_size=346,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
a,b= next(valid_data_gen)
n_preds = model_2.predict_classes(a)
preds = n_preds != np.argmax(b,axis=1)
claz = {0:'plane',1:'tesla',2:'shuttle'}
for img,nn_prediction,expected in zip(a[preds],n_preds[preds],np.argmax(b,axis=1)[preds]):
print(f'{claz[nn_prediction]} expected to be {claz[expected]}')
plt.imshow(img)
plt.show()
In [41]:
valid_data_gen = image_generator.flow_from_directory(directory=str(valid_data_dir),
batch_size=346,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
a,b= next(valid_data_gen)
n_preds = model_3.predict(a)
n_preds = np.argmax(n_preds,axis=1)
preds = n_preds != np.argmax(b,axis=1)
claz = {0:'plane',1:'tesla',2:'shuttle'}
for img,nn_prediction,expected in zip(a[preds],n_preds[preds],np.argmax(b,axis=1)[preds]):
print(f'{claz[nn_prediction]} expected to be {claz[expected]}')
plt.imshow(img)
plt.show()
In [42]:
valid_data_gen = wirdo_image_generator.flow_from_directory(directory=str(train_data_dir),
batch_size=346,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH),
classes = list(CLASS_NAMES))
a,b= next(valid_data_gen)
n_preds = model_4.predict(a)
n_preds = np.argmax(n_preds,axis=1)
preds = n_preds != np.argmax(b,axis=1)
claz = {0:'plane',1:'tesla',2:'shuttle'}
for img,nn_prediction,expected in zip(a[preds],n_preds[preds],np.argmax(b,axis=1)[preds]):
print(f'{claz[nn_prediction]} expected to be {claz[expected]}')
plt.imshow(img)
plt.show()
Jak widać najczęstrze błędy to pomylenie samolotu z promem kosmicznym co nie dziwi z uwagi na to że klasy te są bardzo podobne
In [0]:
valid_data_dir = '/content/dirve/My Drive/Colab Notebooks/TransferLearningData/c_test'
train_data_dir = '/content/dirve/My Drive/Colab Notebooks/TransferLearningData/c_train'
valid_data_dir = pathlib.Path(valid_data_dir)
train_data_dir = pathlib.Path(train_data_dir)
In [70]:
train_data_gen = image_generator.flow_from_directory(directory=str(train_data_dir),
batch_size=BATCH_SIZE,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH))
valid_data_gen = image_generator.flow_from_directory(directory=str(valid_data_dir),
target_size=(IMG_HEIGHT, IMG_WIDTH))
In [71]:
CLASS_NAMES = np.array([item.name for item in train_data_dir.glob('*')])
CLASS_NAMES
Out[71]:
In [0]:
image_batch, label_batch = next(train_data_gen)
In [73]:
show_batch(image_batch,label_batch)
In [74]:
model = keras.applications.VGG19(weights = "imagenet", include_top=False, input_shape = (IMG_HEIGHT, IMG_WIDTH, 3))
for layer in model.layers[:5]:
layer.trainable = False
x = model.output
x = keras.layers.Flatten()(x)
x = keras.layers.Dense(1024, activation="relu")(x)
x = keras.layers.Dropout(0.5)(x)
x = keras.layers.Dense(1024, activation="relu")(x)
predictions = keras.layers.Dense(2, activation="softmax")(x)
model_5 = keras.models.Model(inputs = model.input, outputs = predictions)
model_5.compile(loss = "categorical_crossentropy", optimizer = keras.optimizers.SGD(lr=0.0001, momentum=0.9), metrics=["accuracy"])
history = model_5.fit(train_data_gen,
epochs=10,
validation_data=valid_data_gen)
In [75]:
draw_charts(history)
In [76]:
valid_data_gen = wirdo_image_generator.flow_from_directory(directory=str(valid_data_dir),
batch_size=202,
shuffle=True,
target_size=(IMG_HEIGHT, IMG_WIDTH))
a,b= next(valid_data_gen)
n_preds = model_5.predict(a)
n_preds = np.argmax(n_preds,axis=1)
preds = n_preds != np.argmax(b,axis=1)
claz = {0:'edward',1:'jabami'}
for img,nn_prediction,expected in zip(a[preds],n_preds[preds],np.argmax(b,axis=1)[preds]):
print(f'{claz[nn_prediction]} expected to be {claz[expected]}')
plt.imshow(img)
plt.show()
Sieć nie uczy się do tak wysokiego poziomu jak poprzednio